#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

// 合并所有流程文件的脚本
function mergeFlowFiles() {
    const flowsDir = path.join(__dirname, '.node-red', 'lib', 'flows');
    const mainFlowFile = path.join(__dirname, '.node-red', 'flows.json');
    
    // 检查flows目录是否存在
    if (!fs.existsSync(flowsDir)) {
        console.log('📁 flows目录不存在，创建目录');
        fs.mkdirSync(flowsDir, { recursive: true });
        return;
    }
    
    // 读取所有.json文件
    const files = fs.readdirSync(flowsDir);
    const flowFiles = files.filter(file => file.endsWith('.json'));
    
    if (flowFiles.length === 0) {
        console.log('📄 没有找到独立的流程文件');
        return;
    }
    
    console.log(`🔍 发现 ${flowFiles.length} 个流程文件:`);
    flowFiles.forEach(file => console.log(`  - ${file}`));
    
    // 合并所有流程
    let mergedFlows = [];
    
    // 首先读取主流程文件（如果存在）
    if (fs.existsSync(mainFlowFile)) {
        try {
            const mainContent = fs.readFileSync(mainFlowFile, 'utf8');
            const mainFlows = JSON.parse(mainContent);
            mergedFlows = mergedFlows.concat(mainFlows);
            console.log('✅ 已读取主流程文件');
        } catch (err) {
            console.error('❌ 读取主流程文件失败:', err.message);
        }
    }
    
    // 然后合并独立流程文件
    flowFiles.forEach(file => {
        const filePath = path.join(flowsDir, file);
        try {
            const fileContent = fs.readFileSync(filePath, 'utf8');
            const flows = JSON.parse(fileContent);
            
            // 如果是数组，直接合并
            if (Array.isArray(flows)) {
                mergedFlows = mergedFlows.concat(flows);
            } else {
                // 如果是对象，假设它包含flows属性
                if (flows.flows && Array.isArray(flows.flows)) {
                    mergedFlows = mergedFlows.concat(flows.flows);
                }
            }
            
            console.log(`✅ 已合并: ${file}`);
        } catch (err) {
            console.error(`❌ 读取文件失败 ${file}:`, err.message);
        }
    });
    
    // 去重：确保每个节点ID只出现一次
    const uniqueFlows = [];
    const nodeIds = new Set();
    
    mergedFlows.forEach(node => {
        if (node.id && !nodeIds.has(node.id)) {
            uniqueFlows.push(node);
            nodeIds.add(node.id);
        } else if (!node.id) {
            // 没有ID的节点直接添加
            uniqueFlows.push(node);
        }
    });
    
    // 写入合并后的流程
    try {
        fs.writeFileSync(mainFlowFile, JSON.stringify(uniqueFlows, null, 2));
        console.log(`✅ 流程合并完成，共 ${uniqueFlows.length} 个节点`);
        console.log(`📁 输出文件: ${mainFlowFile}`);
    } catch (err) {
        console.error('❌ 写入合并文件失败:', err.message);
    }
}

// 分离流程文件的脚本
function splitFlowFiles() {
    const mainFlowFile = path.join(__dirname, '.node-red', 'flows.json');
    const flowsDir = path.join(__dirname, '.node-red', 'lib', 'flows');
    
    // 检查主流程文件是否存在
    if (!fs.existsSync(mainFlowFile)) {
        console.log('❌ 主流程文件不存在:', mainFlowFile);
        return;
    }
    
    try {
        const mainContent = fs.readFileSync(mainFlowFile, 'utf8');
        const flows = JSON.parse(mainContent);
        
        // 按tab分组
        const flowGroups = {};
        const tabNodes = {};
        
        // 首先找出所有tab节点
        flows.forEach(node => {
            if (node.type === 'tab') {
                tabNodes[node.id] = node;
                flowGroups[node.id] = [node]; // 包含tab节点本身
            }
        });
        
        // 将其他节点分配到对应的组
        flows.forEach(node => {
            if (node.type !== 'tab') {
                const tabId = node.z; // 节点所属的tab
                if (tabId && flowGroups[tabId]) {
                    flowGroups[tabId].push(node);
                }
            }
        });
        
        // 确保flows目录存在
        if (!fs.existsSync(flowsDir)) {
            fs.mkdirSync(flowsDir, { recursive: true });
        }
        
        // 为每个组创建独立文件
        Object.keys(flowGroups).forEach(tabId => {
            const groupFlows = flowGroups[tabId];
            const tabNode = tabNodes[tabId];
            const groupName = tabNode ? tabNode.label : `group-${tabId}`;
            const fileName = `${groupName.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]/g, '-')}-flow.json`;
            const filePath = path.join(flowsDir, fileName);
            
            try {
                fs.writeFileSync(filePath, JSON.stringify(groupFlows, null, 2));
                console.log(`✅ 已创建流程文件: ${fileName} (${groupFlows.length} 个节点)`);
            } catch (err) {
                console.error(`❌ 创建文件失败 ${fileName}:`, err.message);
            }
        });
        
        console.log(`✅ 流程分离完成，共创建 ${Object.keys(flowGroups).length} 个文件`);
    } catch (err) {
        console.error('❌ 分离流程文件失败:', err.message);
    }
}

// 主函数
function main() {
    const args = process.argv.slice(2);
    
    if (args.includes('--split')) {
        console.log('🔄 分离流程文件...');
        splitFlowFiles();
    } else if (args.includes('--merge')) {
        console.log('🔄 合并流程文件...');
        mergeFlowFiles();
    } else {
        console.log('使用方法:');
        console.log('  node merge-flows.js --merge  # 合并独立流程文件到主文件');
        console.log('  node merge-flows.js --split  # 将主流程文件分离为独立文件');
    }
}

// 执行主函数
main();